package com.Clause;

public class OperateurBinaire extends Operateur{

	public static final String ET = "^";
	public static final String OU = "v";
	public static final String IMPLIQUE	= "->";
	public static final String EQUIVALENT	= "<=>";

	private ClauseProxy precedent;

	public OperateurBinaire(String operateur){
		super(operateur);
	}

	public OperateurBinaire(ClauseProxy elementPrecedent, String operateur, ClauseProxy elementSuivant){
		super(operateur);
		this.precedent = elementPrecedent;
		this.suivant = elementSuivant;
	}
	public OperateurBinaire(ClauseElement elementPrecedent, String operateur, ClauseElement elementSuivant){
		super(operateur);
		this.precedent = new ClauseProxy(elementPrecedent);
		this.suivant = new ClauseProxy(elementSuivant);
	}
	
	public OperateurBinaire(OperateurBinaire op2){
		super(op2.operateur);
	}
	
	public void interchanger(){
		if(operateur.equals(ET))
			operateur = OU;
		else
			if(operateur.equals(OU))
				operateur = ET;
	}

	public void setPrecedent(ClauseProxy proxy){
		precedent = proxy;
	}
	public void setElementPrecedent(ClauseElement element){
		precedent = new ClauseProxy(element);
	}
	
	public ClauseElement getElementPrecedent(){
		return precedent.getElement();
	}

	public ClauseProxy getPrecedent(){
		return precedent;
	}

	public String toString(){
		return precedent.toString()+" "+super.toString();
	}
	
	public String toPrologString(){
		StringBuffer sb = new StringBuffer();
		
		
		
		if(operateur.equals(IMPLIQUE)){
			sb.append(suivant.toPrologString());
			sb.append(" :- ");
			sb.append(precedent.toPrologString());
		}
		else if(operateur.equals(ET)){
			sb.append(suivant.toPrologString());
			if(precedent != null){
				sb.append(" , ");
				sb.append(precedent.toPrologString());
			}
		}
			
		return sb.toString();
		
	}


	public static OperateurBinaire newEt(){
		return new OperateurBinaire(ET);
	}
	public static OperateurBinaire newEt(ClauseElement elementPrecedent, ClauseElement elementSuivant){
		return new OperateurBinaire(new ClauseProxy(elementPrecedent),ET,new ClauseProxy(elementSuivant));
	}
	public static OperateurBinaire newOu(){
		return new OperateurBinaire(OU);
	}
	public static OperateurBinaire newOu(ClauseElement elementPrecedent, ClauseElement elementSuivant){
		return new OperateurBinaire(new ClauseProxy(elementPrecedent),OU,new ClauseProxy(elementSuivant));
	}
	public static OperateurBinaire newImplique(){
		return new OperateurBinaire(IMPLIQUE);
	}
	public static OperateurBinaire newImplique(ClauseElement elementPrecedent, ClauseElement elementSuivant){
		return new OperateurBinaire(new ClauseProxy(elementPrecedent),IMPLIQUE,new ClauseProxy(elementSuivant));
	}
	public static OperateurBinaire newEquivalent(){
		return new OperateurBinaire(EQUIVALENT);
	}
	public static OperateurBinaire newEquivalent(ClauseElement elementPrecedent, ClauseElement elementSuivant){
		return new OperateurBinaire(new ClauseProxy(elementPrecedent),EQUIVALENT,new ClauseProxy(elementSuivant));
	}

	public void changer(String implique) {
		if(implique.equals(EQUIVALENT) || implique.equals(ET) || implique.equals(OU) || implique.equals(IMPLIQUE))
			this.operateur = implique;	
	}
	
	public OperateurBinaire copie(){
		return new OperateurBinaire(precedent.getElement().copie(),new String(operateur),suivant.getElement().copie());
	}


}
